package com.ourteam.education.dao;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;
import org.apache.commons.lang.StringUtils;
/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2019-09-22 15:15:09
  * Warning ! This file will be overwrite when regenerate !
  * 
 */
public class LessonDAOQueryBean extends BaseQueryBean {
    
    public LessonDAOQueryBean() {
		super();
    }
	
    public LessonDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }
    
    public LessonDAOQueryBean(BaseQueryBean aQueryBean,Map tableReplaceMap) {
        super(aQueryBean,tableReplaceMap);
    }
    
    public Criteria createCriteria() {
        
	    Criteria criteria = createCriteriaInternal();
        if (oredCriteria.size() == 0) {
                  oredCriteria.add(criteria);
            }
        return criteria;
     }
	
    protected Criteria createCriteriaInternal() {
	  return new Criteria(this);
    }
    
        
        
    	
		
	    
    public void addIdSelectProperty(){
		addIdSelectProperty("id");
	}
	
    public void addIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.Id,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.Id,"id");
	    }
    }
    
       
		
		
	    
    public void addCampusIdSelectProperty(){
		addCampusIdSelectProperty("campusId");
	}
	
    public void addCampusIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.CampusId,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.CampusId,"campusId");
	    }
    }
    
       
		
		
	    
    public void addClassIdSelectProperty(){
		addClassIdSelectProperty("classId");
	}
	
    public void addClassIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.ClassId,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.ClassId,"classId");
	    }
    }
    
       
		
		
	    
    public void addTeacherIdSelectProperty(){
		addTeacherIdSelectProperty("teacherId");
	}
	
    public void addTeacherIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.TeacherId,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.TeacherId,"teacherId");
	    }
    }
    
       
		
		
	    
    public void addCoursePriceIdSelectProperty(){
		addCoursePriceIdSelectProperty("coursePriceId");
	}
	
    public void addCoursePriceIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.CoursePriceId,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.CoursePriceId,"coursePriceId");
	    }
    }
    
       
		
		
	    
    public void addClassroomIdSelectProperty(){
		addClassroomIdSelectProperty("classroomId");
	}
	
    public void addClassroomIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.ClassroomId,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.ClassroomId,"classroomId");
	    }
    }
    
       
		
		
	    
    public void addRepeatTypeSelectProperty(){
		addRepeatTypeSelectProperty("repeatType");
	}
	
    public void addRepeatTypeSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.RepeatType,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.RepeatType,"repeatType");
	    }
    }
    
       
		
		
	    
    public void addRepeatPeriodSelectProperty(){
		addRepeatPeriodSelectProperty("repeatPeriod");
	}
	
    public void addRepeatPeriodSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.RepeatPeriod,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.RepeatPeriod,"repeatPeriod");
	    }
    }
    
       
		
		
	    
    public void addExcludeHolidaysSelectProperty(){
		addExcludeHolidaysSelectProperty("excludeHolidays");
	}
	
    public void addExcludeHolidaysSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.ExcludeHolidays,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.ExcludeHolidays,"excludeHolidays");
	    }
    }
    
       
		
		
	    
    public void addStartDateSelectProperty(){
		addStartDateSelectProperty("startDate");
	}
	
    public void addStartDateSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.StartDate,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.StartDate,"startDate");
	    }
    }
    
       
		
		
	    
    public void addEndDateSelectProperty(){
		addEndDateSelectProperty("endDate");
	}
	
    public void addEndDateSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.EndDate,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.EndDate,"endDate");
	    }
    }
    
       
		
		
	    
    public void addMaxLessonCountSelectProperty(){
		addMaxLessonCountSelectProperty("maxLessonCount");
	}
	
    public void addMaxLessonCountSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.MaxLessonCount,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.MaxLessonCount,"maxLessonCount");
	    }
    }
    
       
		
		
	    
    public void addStartLessonTimeSelectProperty(){
		addStartLessonTimeSelectProperty("startLessonTime");
	}
	
    public void addStartLessonTimeSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.StartLessonTime,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.StartLessonTime,"startLessonTime");
	    }
    }
    
       
		
		
	    
    public void addEndLessonTimeSelectProperty(){
		addEndLessonTimeSelectProperty("endLessonTime");
	}
	
    public void addEndLessonTimeSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.EndLessonTime,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.EndLessonTime,"endLessonTime");
	    }
    }
    
       
		
		
	    
    public void addLessonTopicSelectProperty(){
		addLessonTopicSelectProperty("lessonTopic");
	}
	
    public void addLessonTopicSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.LessonTopic,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.LessonTopic,"lessonTopic");
	    }
    }
    
       
		
		
	    
    public void addDeleteFlagSelectProperty(){
		addDeleteFlagSelectProperty("deleteFlag");
	}
	
    public void addDeleteFlagSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.DeleteFlag,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.DeleteFlag,"deleteFlag");
	    }
    }
    
       
		
		
	    
    public void addStatusSelectProperty(){
		addStatusSelectProperty("status");
	}
	
    public void addStatusSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.Status,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.Status,"status");
	    }
    }
    
       
		
		
	    
    public void addRemarksSelectProperty(){
		addRemarksSelectProperty("remarks");
	}
	
    public void addRemarksSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.Remarks,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.Remarks,"remarks");
	    }
    }
    
       
		
		
	    
    public void addCourseIdSelectProperty(){
		addCourseIdSelectProperty("courseId");
	}
	
    public void addCourseIdSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.CourseId,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.CourseId,"courseId");
	    }
    }
    
       
		
						
	    
    public void addCampusNameSelectProperty(){
		addCampusNameSelectProperty("campusName");
	}
	
    public void addCampusNameSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.CampusName,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.CampusName,"campusName");
	    }
    }
    
    	
								
	    
    public void addClassroomNameSelectProperty(){
		addClassroomNameSelectProperty("classroomName");
	}
	
    public void addClassroomNameSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.ClassroomName,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.ClassroomName,"classroomName");
	    }
    }
    
    	
								
	    
    public void addClassNameSelectProperty(){
		addClassNameSelectProperty("className");
	}
	
    public void addClassNameSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.ClassName,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.ClassName,"className");
	    }
    }
    
    	
								
	    
    public void addTeacherNameSelectProperty(){
		addTeacherNameSelectProperty("teacherName");
	}
	
    public void addTeacherNameSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.TeacherName,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.TeacherName,"teacherName");
	    }
    }
    
    	
								
	    
    public void addCourseNameSelectProperty(){
		addCourseNameSelectProperty("courseName");
	}
	
    public void addCourseNameSelectProperty(String aAlias){
		if(StringUtils.isNotBlank(aAlias)){
			addSelectProperty(ILessonDAO.CourseName,aAlias);
		}
		else{
			addSelectProperty(ILessonDAO.CourseName,"courseName");
	    }
    }
    
    	
				
	public void addAllSelectProperties(){
		
		
	    addIdSelectProperty();
   
		
		
	    addCampusIdSelectProperty();
   
		
		
	    addClassIdSelectProperty();
   
		
		
	    addTeacherIdSelectProperty();
   
		
		
	    addCoursePriceIdSelectProperty();
   
		
		
	    addClassroomIdSelectProperty();
   
		
		
	    addRepeatTypeSelectProperty();
   
		
		
	    addRepeatPeriodSelectProperty();
   
		
		
	    addExcludeHolidaysSelectProperty();
   
		
		
	    addStartDateSelectProperty();
   
		
		
	    addEndDateSelectProperty();
   
		
		
	    addMaxLessonCountSelectProperty();
   
		
		
	    addStartLessonTimeSelectProperty();
   
		
		
	    addEndLessonTimeSelectProperty();
   
		
		
	    addLessonTopicSelectProperty();
   
		
		
	    addDeleteFlagSelectProperty();
   
		
		
	    addStatusSelectProperty();
   
		
		
	    addRemarksSelectProperty();
   
		
		
	    addCourseIdSelectProperty();
   
		
						
    	addCampusNameSelectProperty();
	
								
    	addClassroomNameSelectProperty();
	
								
    	addClassNameSelectProperty();
	
								
    	addTeacherNameSelectProperty();
	
								
    	addCourseNameSelectProperty();
	
			    }
    
    public static class Criteria extends BaseWhereCriterion<LessonDAOQueryBean> {
	
        protected Criteria(LessonDAOQueryBean aParentObject) {
		    super(aParentObject);
        }
        
                  
            	
    	    	
    	        
                
        public Criteria andIdIsNull() {
            addCriterion(ILessonDAO.Id + " is null");
            return this;
        }
        public Criteria andIdIsNotNull() {
            addCriterion(ILessonDAO.Id + " is not null");
            return this;
        }
    
        public Criteria andIdIsNotEmpty() {        
            addCriterion(ILessonDAO.Id + " is not null AND " + ILessonDAO.Id + " <> ''");
            return this;
        }
    		
    	public Criteria andIdIsEmpty() {       
            addCriterion("(" + ILessonDAO.Id + " is null OR " + ILessonDAO.Id + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andIdEqualTo(long value) {
        	return andIdEqualTo(Long.valueOf(value));
        }
               public Criteria andIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.Id + " = ", value, "id");
            return this;
        }
        
        public Criteria andIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.Id);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Id + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andIdNotEqualTo(long value) {
        	return andIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.Id + " <>", value, "id");
            return this;
        }
               
        public Criteria andIdNotEqualToOrIsNull(long value) {
        	return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.Id + " is null OR " + ILessonDAO.Id + " <>", value, "id");
            return this;
        }
        
        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.Id);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Id + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andIdGreaterThan(long value) {
        	return andIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.Id + " >", value, "id");
            return this;
        }
        
        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.Id);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Id + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andIdGreaterThanOrEqualTo(long value) {
        	return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.Id + " >=", value, "id");
            return this;
        }
        
        public Criteria andIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.Id);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Id + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andIdLessThan(long value) {
        	return andIdLessThan(Long.valueOf(value));
        }
                public Criteria andIdLessThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.Id + " <", value, "id");
            return this;
        }
        
        public Criteria andIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.Id);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Id + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andIdLessThanOrEqualTo(long value) {
        	return andIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.Id + " <=", value, "id");
            return this;
        }
        
        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.Id);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Id + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andIdIn(long[] values) {
        	if(values.length == 1){
        		return andIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.Id + " in", values, "id");
            	return this;
            }
        }
        
        public Criteria andIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.Id + " not in", values, "id");
            	return this;
            }
        }
        
                public Criteria andIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.Id + " in", values, "id");
            	return this;
            }
        }
        public Criteria andIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.Id + " not in", values, "id");
            	return this;
            }
        }
        
        public Criteria andIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.Id + " in", Arrays.asList(values), "id");
            	return this;
            }
        }
        public Criteria andIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.Id + " not in", Arrays.asList(values), "id");
            	return this;
            }
        }
		
		public Criteria andIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Id + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Id + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andIdBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.Id + " between", value1, value2, "id");
            return this;
        }
                public Criteria andIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.Id + " between", value1, value2, "id");
            return this;
        }
        
                
        public Criteria andIdNotBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.Id + " not between", value1, value2, "id");
            return this;
        }
                public Criteria andIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.Id + " not between", value1, value2, "id");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andCampusIdIsNull() {
            addCriterion(ILessonDAO.CampusId + " is null");
            return this;
        }
        public Criteria andCampusIdIsNotNull() {
            addCriterion(ILessonDAO.CampusId + " is not null");
            return this;
        }
    
        public Criteria andCampusIdIsNotEmpty() {        
            addCriterion(ILessonDAO.CampusId + " is not null AND " + ILessonDAO.CampusId + " <> ''");
            return this;
        }
    		
    	public Criteria andCampusIdIsEmpty() {       
            addCriterion("(" + ILessonDAO.CampusId + " is null OR " + ILessonDAO.CampusId + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andCampusIdEqualTo(long value) {
        	return andCampusIdEqualTo(Long.valueOf(value));
        }
               public Criteria andCampusIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CampusId + " = ", value, "campusId");
            return this;
        }
        
        public Criteria andCampusIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CampusId);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusId + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andCampusIdNotEqualTo(long value) {
        	return andCampusIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andCampusIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.CampusId + " <>", value, "campusId");
            return this;
        }
               
        public Criteria andCampusIdNotEqualToOrIsNull(long value) {
        	return andCampusIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andCampusIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.CampusId + " is null OR " + ILessonDAO.CampusId + " <>", value, "campusId");
            return this;
        }
        
        public Criteria andCampusIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CampusId);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusId + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andCampusIdGreaterThan(long value) {
        	return andCampusIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andCampusIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CampusId + " >", value, "campusId");
            return this;
        }
        
        public Criteria andCampusIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CampusId);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusId + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andCampusIdGreaterThanOrEqualTo(long value) {
        	return andCampusIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andCampusIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CampusId + " >=", value, "campusId");
            return this;
        }
        
        public Criteria andCampusIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CampusId);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusId + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCampusIdLessThan(long value) {
        	return andCampusIdLessThan(Long.valueOf(value));
        }
                public Criteria andCampusIdLessThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CampusId + " <", value, "campusId");
            return this;
        }
        
        public Criteria andCampusIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CampusId);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusId + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCampusIdLessThanOrEqualTo(long value) {
        	return andCampusIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andCampusIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CampusId + " <=", value, "campusId");
            return this;
        }
        
        public Criteria andCampusIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CampusId);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusId + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andCampusIdIn(long[] values) {
        	if(values.length == 1){
        		return andCampusIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CampusId + " in", values, "campusId");
            	return this;
            }
        }
        
        public Criteria andCampusIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andCampusIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CampusId + " not in", values, "campusId");
            	return this;
            }
        }
        
                public Criteria andCampusIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andCampusIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CampusId + " in", values, "campusId");
            	return this;
            }
        }
        public Criteria andCampusIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andCampusIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CampusId + " not in", values, "campusId");
            	return this;
            }
        }
        
        public Criteria andCampusIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andCampusIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CampusId + " in", Arrays.asList(values), "campusId");
            	return this;
            }
        }
        public Criteria andCampusIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andCampusIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CampusId + " not in", Arrays.asList(values), "campusId");
            	return this;
            }
        }
		
		public Criteria andCampusIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusId + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andCampusIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusId + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCampusIdBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.CampusId + " between", value1, value2, "campusId");
            return this;
        }
                public Criteria andCampusIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.CampusId + " between", value1, value2, "campusId");
            return this;
        }
        
                
        public Criteria andCampusIdNotBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.CampusId + " not between", value1, value2, "campusId");
            return this;
        }
                public Criteria andCampusIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.CampusId + " not between", value1, value2, "campusId");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andClassIdIsNull() {
            addCriterion(ILessonDAO.ClassId + " is null");
            return this;
        }
        public Criteria andClassIdIsNotNull() {
            addCriterion(ILessonDAO.ClassId + " is not null");
            return this;
        }
    
        public Criteria andClassIdIsNotEmpty() {        
            addCriterion(ILessonDAO.ClassId + " is not null AND " + ILessonDAO.ClassId + " <> ''");
            return this;
        }
    		
    	public Criteria andClassIdIsEmpty() {       
            addCriterion("(" + ILessonDAO.ClassId + " is null OR " + ILessonDAO.ClassId + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andClassIdEqualTo(long value) {
        	return andClassIdEqualTo(Long.valueOf(value));
        }
               public Criteria andClassIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassId + " = ", value, "classId");
            return this;
        }
        
        public Criteria andClassIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassId);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassId + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andClassIdNotEqualTo(long value) {
        	return andClassIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andClassIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.ClassId + " <>", value, "classId");
            return this;
        }
               
        public Criteria andClassIdNotEqualToOrIsNull(long value) {
        	return andClassIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andClassIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.ClassId + " is null OR " + ILessonDAO.ClassId + " <>", value, "classId");
            return this;
        }
        
        public Criteria andClassIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassId);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassId + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andClassIdGreaterThan(long value) {
        	return andClassIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andClassIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassId + " >", value, "classId");
            return this;
        }
        
        public Criteria andClassIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassId);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassId + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andClassIdGreaterThanOrEqualTo(long value) {
        	return andClassIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andClassIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassId + " >=", value, "classId");
            return this;
        }
        
        public Criteria andClassIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassId);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassId + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andClassIdLessThan(long value) {
        	return andClassIdLessThan(Long.valueOf(value));
        }
                public Criteria andClassIdLessThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassId + " <", value, "classId");
            return this;
        }
        
        public Criteria andClassIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassId);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassId + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andClassIdLessThanOrEqualTo(long value) {
        	return andClassIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andClassIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassId + " <=", value, "classId");
            return this;
        }
        
        public Criteria andClassIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassId);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassId + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andClassIdIn(long[] values) {
        	if(values.length == 1){
        		return andClassIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassId + " in", values, "classId");
            	return this;
            }
        }
        
        public Criteria andClassIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andClassIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassId + " not in", values, "classId");
            	return this;
            }
        }
        
                public Criteria andClassIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andClassIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ClassId + " in", values, "classId");
            	return this;
            }
        }
        public Criteria andClassIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andClassIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ClassId + " not in", values, "classId");
            	return this;
            }
        }
        
        public Criteria andClassIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andClassIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassId + " in", Arrays.asList(values), "classId");
            	return this;
            }
        }
        public Criteria andClassIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andClassIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassId + " not in", Arrays.asList(values), "classId");
            	return this;
            }
        }
		
		public Criteria andClassIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassId + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andClassIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassId + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andClassIdBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.ClassId + " between", value1, value2, "classId");
            return this;
        }
                public Criteria andClassIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.ClassId + " between", value1, value2, "classId");
            return this;
        }
        
                
        public Criteria andClassIdNotBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.ClassId + " not between", value1, value2, "classId");
            return this;
        }
                public Criteria andClassIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.ClassId + " not between", value1, value2, "classId");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andTeacherIdIsNull() {
            addCriterion(ILessonDAO.TeacherId + " is null");
            return this;
        }
        public Criteria andTeacherIdIsNotNull() {
            addCriterion(ILessonDAO.TeacherId + " is not null");
            return this;
        }
    
        public Criteria andTeacherIdIsNotEmpty() {        
            addCriterion(ILessonDAO.TeacherId + " is not null AND " + ILessonDAO.TeacherId + " <> ''");
            return this;
        }
    		
    	public Criteria andTeacherIdIsEmpty() {       
            addCriterion("(" + ILessonDAO.TeacherId + " is null OR " + ILessonDAO.TeacherId + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andTeacherIdEqualTo(long value) {
        	return andTeacherIdEqualTo(Long.valueOf(value));
        }
               public Criteria andTeacherIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.TeacherId + " = ", value, "teacherId");
            return this;
        }
        
        public Criteria andTeacherIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.TeacherId);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherId + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andTeacherIdNotEqualTo(long value) {
        	return andTeacherIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andTeacherIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.TeacherId + " <>", value, "teacherId");
            return this;
        }
               
        public Criteria andTeacherIdNotEqualToOrIsNull(long value) {
        	return andTeacherIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andTeacherIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.TeacherId + " is null OR " + ILessonDAO.TeacherId + " <>", value, "teacherId");
            return this;
        }
        
        public Criteria andTeacherIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.TeacherId);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherId + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andTeacherIdGreaterThan(long value) {
        	return andTeacherIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andTeacherIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.TeacherId + " >", value, "teacherId");
            return this;
        }
        
        public Criteria andTeacherIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.TeacherId);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherId + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andTeacherIdGreaterThanOrEqualTo(long value) {
        	return andTeacherIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andTeacherIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.TeacherId + " >=", value, "teacherId");
            return this;
        }
        
        public Criteria andTeacherIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.TeacherId);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherId + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andTeacherIdLessThan(long value) {
        	return andTeacherIdLessThan(Long.valueOf(value));
        }
                public Criteria andTeacherIdLessThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.TeacherId + " <", value, "teacherId");
            return this;
        }
        
        public Criteria andTeacherIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.TeacherId);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherId + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andTeacherIdLessThanOrEqualTo(long value) {
        	return andTeacherIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andTeacherIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.TeacherId + " <=", value, "teacherId");
            return this;
        }
        
        public Criteria andTeacherIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.TeacherId);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherId + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andTeacherIdIn(long[] values) {
        	if(values.length == 1){
        		return andTeacherIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherId + " in", values, "teacherId");
            	return this;
            }
        }
        
        public Criteria andTeacherIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andTeacherIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherId + " not in", values, "teacherId");
            	return this;
            }
        }
        
                public Criteria andTeacherIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andTeacherIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherId + " in", values, "teacherId");
            	return this;
            }
        }
        public Criteria andTeacherIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andTeacherIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherId + " not in", values, "teacherId");
            	return this;
            }
        }
        
        public Criteria andTeacherIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andTeacherIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherId + " in", Arrays.asList(values), "teacherId");
            	return this;
            }
        }
        public Criteria andTeacherIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andTeacherIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherId + " not in", Arrays.asList(values), "teacherId");
            	return this;
            }
        }
		
		public Criteria andTeacherIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherId + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andTeacherIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherId + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andTeacherIdBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.TeacherId + " between", value1, value2, "teacherId");
            return this;
        }
                public Criteria andTeacherIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.TeacherId + " between", value1, value2, "teacherId");
            return this;
        }
        
                
        public Criteria andTeacherIdNotBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.TeacherId + " not between", value1, value2, "teacherId");
            return this;
        }
                public Criteria andTeacherIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.TeacherId + " not between", value1, value2, "teacherId");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andCoursePriceIdIsNull() {
            addCriterion(ILessonDAO.CoursePriceId + " is null");
            return this;
        }
        public Criteria andCoursePriceIdIsNotNull() {
            addCriterion(ILessonDAO.CoursePriceId + " is not null");
            return this;
        }
    
        public Criteria andCoursePriceIdIsNotEmpty() {        
            addCriterion(ILessonDAO.CoursePriceId + " is not null AND " + ILessonDAO.CoursePriceId + " <> ''");
            return this;
        }
    		
    	public Criteria andCoursePriceIdIsEmpty() {       
            addCriterion("(" + ILessonDAO.CoursePriceId + " is null OR " + ILessonDAO.CoursePriceId + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andCoursePriceIdEqualTo(long value) {
        	return andCoursePriceIdEqualTo(Long.valueOf(value));
        }
               public Criteria andCoursePriceIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CoursePriceId + " = ", value, "coursePriceId");
            return this;
        }
        
        public Criteria andCoursePriceIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CoursePriceId);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCoursePriceIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CoursePriceId + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andCoursePriceIdNotEqualTo(long value) {
        	return andCoursePriceIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andCoursePriceIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.CoursePriceId + " <>", value, "coursePriceId");
            return this;
        }
               
        public Criteria andCoursePriceIdNotEqualToOrIsNull(long value) {
        	return andCoursePriceIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andCoursePriceIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.CoursePriceId + " is null OR " + ILessonDAO.CoursePriceId + " <>", value, "coursePriceId");
            return this;
        }
        
        public Criteria andCoursePriceIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CoursePriceId);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCoursePriceIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CoursePriceId + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andCoursePriceIdGreaterThan(long value) {
        	return andCoursePriceIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andCoursePriceIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CoursePriceId + " >", value, "coursePriceId");
            return this;
        }
        
        public Criteria andCoursePriceIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CoursePriceId);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCoursePriceIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CoursePriceId + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andCoursePriceIdGreaterThanOrEqualTo(long value) {
        	return andCoursePriceIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andCoursePriceIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CoursePriceId + " >=", value, "coursePriceId");
            return this;
        }
        
        public Criteria andCoursePriceIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CoursePriceId);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCoursePriceIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CoursePriceId + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCoursePriceIdLessThan(long value) {
        	return andCoursePriceIdLessThan(Long.valueOf(value));
        }
                public Criteria andCoursePriceIdLessThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CoursePriceId + " <", value, "coursePriceId");
            return this;
        }
        
        public Criteria andCoursePriceIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CoursePriceId);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCoursePriceIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CoursePriceId + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCoursePriceIdLessThanOrEqualTo(long value) {
        	return andCoursePriceIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andCoursePriceIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CoursePriceId + " <=", value, "coursePriceId");
            return this;
        }
        
        public Criteria andCoursePriceIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CoursePriceId);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCoursePriceIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CoursePriceId + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andCoursePriceIdIn(long[] values) {
        	if(values.length == 1){
        		return andCoursePriceIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CoursePriceId + " in", values, "coursePriceId");
            	return this;
            }
        }
        
        public Criteria andCoursePriceIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andCoursePriceIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CoursePriceId + " not in", values, "coursePriceId");
            	return this;
            }
        }
        
                public Criteria andCoursePriceIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andCoursePriceIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CoursePriceId + " in", values, "coursePriceId");
            	return this;
            }
        }
        public Criteria andCoursePriceIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andCoursePriceIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CoursePriceId + " not in", values, "coursePriceId");
            	return this;
            }
        }
        
        public Criteria andCoursePriceIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andCoursePriceIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CoursePriceId + " in", Arrays.asList(values), "coursePriceId");
            	return this;
            }
        }
        public Criteria andCoursePriceIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andCoursePriceIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CoursePriceId + " not in", Arrays.asList(values), "coursePriceId");
            	return this;
            }
        }
		
		public Criteria andCoursePriceIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CoursePriceId + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andCoursePriceIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CoursePriceId + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCoursePriceIdBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.CoursePriceId + " between", value1, value2, "coursePriceId");
            return this;
        }
                public Criteria andCoursePriceIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.CoursePriceId + " between", value1, value2, "coursePriceId");
            return this;
        }
        
                
        public Criteria andCoursePriceIdNotBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.CoursePriceId + " not between", value1, value2, "coursePriceId");
            return this;
        }
                public Criteria andCoursePriceIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.CoursePriceId + " not between", value1, value2, "coursePriceId");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andClassroomIdIsNull() {
            addCriterion(ILessonDAO.ClassroomId + " is null");
            return this;
        }
        public Criteria andClassroomIdIsNotNull() {
            addCriterion(ILessonDAO.ClassroomId + " is not null");
            return this;
        }
    
        public Criteria andClassroomIdIsNotEmpty() {        
            addCriterion(ILessonDAO.ClassroomId + " is not null AND " + ILessonDAO.ClassroomId + " <> ''");
            return this;
        }
    		
    	public Criteria andClassroomIdIsEmpty() {       
            addCriterion("(" + ILessonDAO.ClassroomId + " is null OR " + ILessonDAO.ClassroomId + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andClassroomIdEqualTo(long value) {
        	return andClassroomIdEqualTo(Long.valueOf(value));
        }
               public Criteria andClassroomIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassroomId + " = ", value, "classroomId");
            return this;
        }
        
        public Criteria andClassroomIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassroomId);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomId + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andClassroomIdNotEqualTo(long value) {
        	return andClassroomIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andClassroomIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.ClassroomId + " <>", value, "classroomId");
            return this;
        }
               
        public Criteria andClassroomIdNotEqualToOrIsNull(long value) {
        	return andClassroomIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andClassroomIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.ClassroomId + " is null OR " + ILessonDAO.ClassroomId + " <>", value, "classroomId");
            return this;
        }
        
        public Criteria andClassroomIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassroomId);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomId + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andClassroomIdGreaterThan(long value) {
        	return andClassroomIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andClassroomIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassroomId + " >", value, "classroomId");
            return this;
        }
        
        public Criteria andClassroomIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassroomId);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomId + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andClassroomIdGreaterThanOrEqualTo(long value) {
        	return andClassroomIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andClassroomIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassroomId + " >=", value, "classroomId");
            return this;
        }
        
        public Criteria andClassroomIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassroomId);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomId + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andClassroomIdLessThan(long value) {
        	return andClassroomIdLessThan(Long.valueOf(value));
        }
                public Criteria andClassroomIdLessThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassroomId + " <", value, "classroomId");
            return this;
        }
        
        public Criteria andClassroomIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassroomId);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomId + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andClassroomIdLessThanOrEqualTo(long value) {
        	return andClassroomIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andClassroomIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.ClassroomId + " <=", value, "classroomId");
            return this;
        }
        
        public Criteria andClassroomIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassroomId);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomId + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andClassroomIdIn(long[] values) {
        	if(values.length == 1){
        		return andClassroomIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomId + " in", values, "classroomId");
            	return this;
            }
        }
        
        public Criteria andClassroomIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andClassroomIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomId + " not in", values, "classroomId");
            	return this;
            }
        }
        
                public Criteria andClassroomIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andClassroomIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomId + " in", values, "classroomId");
            	return this;
            }
        }
        public Criteria andClassroomIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andClassroomIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomId + " not in", values, "classroomId");
            	return this;
            }
        }
        
        public Criteria andClassroomIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andClassroomIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomId + " in", Arrays.asList(values), "classroomId");
            	return this;
            }
        }
        public Criteria andClassroomIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andClassroomIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomId + " not in", Arrays.asList(values), "classroomId");
            	return this;
            }
        }
		
		public Criteria andClassroomIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomId + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andClassroomIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomId + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andClassroomIdBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.ClassroomId + " between", value1, value2, "classroomId");
            return this;
        }
                public Criteria andClassroomIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.ClassroomId + " between", value1, value2, "classroomId");
            return this;
        }
        
                
        public Criteria andClassroomIdNotBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.ClassroomId + " not between", value1, value2, "classroomId");
            return this;
        }
                public Criteria andClassroomIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.ClassroomId + " not between", value1, value2, "classroomId");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andRepeatTypeIsNull() {
            addCriterion(ILessonDAO.RepeatType + " is null");
            return this;
        }
        public Criteria andRepeatTypeIsNotNull() {
            addCriterion(ILessonDAO.RepeatType + " is not null");
            return this;
        }
    
        public Criteria andRepeatTypeIsNotEmpty() {        
            addCriterion(ILessonDAO.RepeatType + " is not null AND " + ILessonDAO.RepeatType + " <> ''");
            return this;
        }
    		
    	public Criteria andRepeatTypeIsEmpty() {       
            addCriterion("(" + ILessonDAO.RepeatType + " is null OR " + ILessonDAO.RepeatType + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andRepeatTypeEqualTo(String value) {
        				
            addCriterion(ILessonDAO.RepeatType + " = ", value, "repeatType");
            return this;
        }
        
        public Criteria andRepeatTypeEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.RepeatType);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatTypeEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatType + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andRepeatTypeNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.RepeatType + " <>", value, "repeatType");
            return this;
        }
               
        public Criteria andRepeatTypeNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.RepeatType + " is null OR " + ILessonDAO.RepeatType + " <>", value, "repeatType");
            return this;
        }
        
        public Criteria andRepeatTypeNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.RepeatType);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatTypeNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatType + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andRepeatTypeGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.RepeatType + " >", value, "repeatType");
            return this;
        }
        
        public Criteria andRepeatTypeGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.RepeatType);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatTypeGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatType + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andRepeatTypeGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.RepeatType + " >=", value, "repeatType");
            return this;
        }
        
        public Criteria andRepeatTypeGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.RepeatType);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatTypeGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatType + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRepeatTypeLessThan(String value) {
        				
            addCriterion(ILessonDAO.RepeatType + " <", value, "repeatType");
            return this;
        }
        
        public Criteria andRepeatTypeLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.RepeatType);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatTypeLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatType + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRepeatTypeLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.RepeatType + " <=", value, "repeatType");
            return this;
        }
        
        public Criteria andRepeatTypeLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.RepeatType);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatTypeLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatType + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andRepeatTypeLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.RepeatType + " like", buffer.toString(), "repeatType");
            return this;
        }
        public Criteria andRepeatTypeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.RepeatType + " not like", buffer.toString(), "repeatType");
            return this;
        }
                
                public Criteria andRepeatTypeIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andRepeatTypeEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.RepeatType + " in", values, "repeatType");
            	return this;
            }
        }
        public Criteria andRepeatTypeNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andRepeatTypeNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.RepeatType + " not in", values, "repeatType");
            	return this;
            }
        }
        
        public Criteria andRepeatTypeIn(String[] values) {
        	
        	if(values.length == 1){
        		return andRepeatTypeEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.RepeatType + " in", Arrays.asList(values), "repeatType");
            	return this;
            }
        }
        public Criteria andRepeatTypeNotIn(String[] values) {
        	if(values.length == 1){
        		return andRepeatTypeNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.RepeatType + " not in", Arrays.asList(values), "repeatType");
            	return this;
            }
        }
		
		public Criteria andRepeatTypeIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatType + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andRepeatTypeNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatType + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRepeatTypeBetween(String value1, String value2) {
            addCriterion(ILessonDAO.RepeatType + " between", value1, value2, "repeatType");
            return this;
        }
        
                public Criteria andRepeatTypeNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.RepeatType + " not between", value1, value2, "repeatType");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andRepeatPeriodIsNull() {
            addCriterion(ILessonDAO.RepeatPeriod + " is null");
            return this;
        }
        public Criteria andRepeatPeriodIsNotNull() {
            addCriterion(ILessonDAO.RepeatPeriod + " is not null");
            return this;
        }
    
        public Criteria andRepeatPeriodIsNotEmpty() {        
            addCriterion(ILessonDAO.RepeatPeriod + " is not null AND " + ILessonDAO.RepeatPeriod + " <> ''");
            return this;
        }
    		
    	public Criteria andRepeatPeriodIsEmpty() {       
            addCriterion("(" + ILessonDAO.RepeatPeriod + " is null OR " + ILessonDAO.RepeatPeriod + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andRepeatPeriodEqualTo(String value) {
        				
            addCriterion(ILessonDAO.RepeatPeriod + " = ", value, "repeatPeriod");
            return this;
        }
        
        public Criteria andRepeatPeriodEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.RepeatPeriod);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatPeriodEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatPeriod + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andRepeatPeriodNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.RepeatPeriod + " <>", value, "repeatPeriod");
            return this;
        }
               
        public Criteria andRepeatPeriodNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.RepeatPeriod + " is null OR " + ILessonDAO.RepeatPeriod + " <>", value, "repeatPeriod");
            return this;
        }
        
        public Criteria andRepeatPeriodNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.RepeatPeriod);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatPeriodNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatPeriod + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andRepeatPeriodGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.RepeatPeriod + " >", value, "repeatPeriod");
            return this;
        }
        
        public Criteria andRepeatPeriodGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.RepeatPeriod);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatPeriodGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatPeriod + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andRepeatPeriodGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.RepeatPeriod + " >=", value, "repeatPeriod");
            return this;
        }
        
        public Criteria andRepeatPeriodGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.RepeatPeriod);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatPeriodGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatPeriod + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRepeatPeriodLessThan(String value) {
        				
            addCriterion(ILessonDAO.RepeatPeriod + " <", value, "repeatPeriod");
            return this;
        }
        
        public Criteria andRepeatPeriodLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.RepeatPeriod);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatPeriodLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatPeriod + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRepeatPeriodLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.RepeatPeriod + " <=", value, "repeatPeriod");
            return this;
        }
        
        public Criteria andRepeatPeriodLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.RepeatPeriod);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRepeatPeriodLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatPeriod + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andRepeatPeriodLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.RepeatPeriod + " like", buffer.toString(), "repeatPeriod");
            return this;
        }
        public Criteria andRepeatPeriodNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.RepeatPeriod + " not like", buffer.toString(), "repeatPeriod");
            return this;
        }
                
                public Criteria andRepeatPeriodIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andRepeatPeriodEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.RepeatPeriod + " in", values, "repeatPeriod");
            	return this;
            }
        }
        public Criteria andRepeatPeriodNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andRepeatPeriodNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.RepeatPeriod + " not in", values, "repeatPeriod");
            	return this;
            }
        }
        
        public Criteria andRepeatPeriodIn(String[] values) {
        	
        	if(values.length == 1){
        		return andRepeatPeriodEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.RepeatPeriod + " in", Arrays.asList(values), "repeatPeriod");
            	return this;
            }
        }
        public Criteria andRepeatPeriodNotIn(String[] values) {
        	if(values.length == 1){
        		return andRepeatPeriodNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.RepeatPeriod + " not in", Arrays.asList(values), "repeatPeriod");
            	return this;
            }
        }
		
		public Criteria andRepeatPeriodIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatPeriod + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andRepeatPeriodNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.RepeatPeriod + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRepeatPeriodBetween(String value1, String value2) {
            addCriterion(ILessonDAO.RepeatPeriod + " between", value1, value2, "repeatPeriod");
            return this;
        }
        
                public Criteria andRepeatPeriodNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.RepeatPeriod + " not between", value1, value2, "repeatPeriod");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andExcludeHolidaysIsNull() {
            addCriterion(ILessonDAO.ExcludeHolidays + " is null");
            return this;
        }
        public Criteria andExcludeHolidaysIsNotNull() {
            addCriterion(ILessonDAO.ExcludeHolidays + " is not null");
            return this;
        }
    
        public Criteria andExcludeHolidaysIsNotEmpty() {        
            addCriterion(ILessonDAO.ExcludeHolidays + " is not null AND " + ILessonDAO.ExcludeHolidays + " <> ''");
            return this;
        }
    		
    	public Criteria andExcludeHolidaysIsEmpty() {       
            addCriterion("(" + ILessonDAO.ExcludeHolidays + " is null OR " + ILessonDAO.ExcludeHolidays + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andExcludeHolidaysEqualTo(String value) {
        				
            addCriterion(ILessonDAO.ExcludeHolidays + " = ", value, "excludeHolidays");
            return this;
        }
        
        public Criteria andExcludeHolidaysEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ExcludeHolidays);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andExcludeHolidaysEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ExcludeHolidays + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andExcludeHolidaysNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.ExcludeHolidays + " <>", value, "excludeHolidays");
            return this;
        }
               
        public Criteria andExcludeHolidaysNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.ExcludeHolidays + " is null OR " + ILessonDAO.ExcludeHolidays + " <>", value, "excludeHolidays");
            return this;
        }
        
        public Criteria andExcludeHolidaysNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ExcludeHolidays);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andExcludeHolidaysNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ExcludeHolidays + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andExcludeHolidaysGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.ExcludeHolidays + " >", value, "excludeHolidays");
            return this;
        }
        
        public Criteria andExcludeHolidaysGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ExcludeHolidays);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andExcludeHolidaysGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ExcludeHolidays + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andExcludeHolidaysGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.ExcludeHolidays + " >=", value, "excludeHolidays");
            return this;
        }
        
        public Criteria andExcludeHolidaysGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ExcludeHolidays);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andExcludeHolidaysGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ExcludeHolidays + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andExcludeHolidaysLessThan(String value) {
        				
            addCriterion(ILessonDAO.ExcludeHolidays + " <", value, "excludeHolidays");
            return this;
        }
        
        public Criteria andExcludeHolidaysLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ExcludeHolidays);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andExcludeHolidaysLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ExcludeHolidays + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andExcludeHolidaysLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.ExcludeHolidays + " <=", value, "excludeHolidays");
            return this;
        }
        
        public Criteria andExcludeHolidaysLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ExcludeHolidays);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andExcludeHolidaysLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ExcludeHolidays + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andExcludeHolidaysLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.ExcludeHolidays + " like", buffer.toString(), "excludeHolidays");
            return this;
        }
        public Criteria andExcludeHolidaysNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.ExcludeHolidays + " not like", buffer.toString(), "excludeHolidays");
            return this;
        }
                
                public Criteria andExcludeHolidaysIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andExcludeHolidaysEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ExcludeHolidays + " in", values, "excludeHolidays");
            	return this;
            }
        }
        public Criteria andExcludeHolidaysNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andExcludeHolidaysNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ExcludeHolidays + " not in", values, "excludeHolidays");
            	return this;
            }
        }
        
        public Criteria andExcludeHolidaysIn(String[] values) {
        	
        	if(values.length == 1){
        		return andExcludeHolidaysEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ExcludeHolidays + " in", Arrays.asList(values), "excludeHolidays");
            	return this;
            }
        }
        public Criteria andExcludeHolidaysNotIn(String[] values) {
        	if(values.length == 1){
        		return andExcludeHolidaysNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ExcludeHolidays + " not in", Arrays.asList(values), "excludeHolidays");
            	return this;
            }
        }
		
		public Criteria andExcludeHolidaysIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ExcludeHolidays + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andExcludeHolidaysNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ExcludeHolidays + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andExcludeHolidaysBetween(String value1, String value2) {
            addCriterion(ILessonDAO.ExcludeHolidays + " between", value1, value2, "excludeHolidays");
            return this;
        }
        
                public Criteria andExcludeHolidaysNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.ExcludeHolidays + " not between", value1, value2, "excludeHolidays");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andStartDateIsNull() {
            addCriterion(ILessonDAO.StartDate + " is null");
            return this;
        }
        public Criteria andStartDateIsNotNull() {
            addCriterion(ILessonDAO.StartDate + " is not null");
            return this;
        }
    
        public Criteria andStartDateIsNotEmpty() {        
            addCriterion(ILessonDAO.StartDate + " is not null AND " + ILessonDAO.StartDate + " <> ''");
            return this;
        }
    		
    	public Criteria andStartDateIsEmpty() {       
            addCriterion("(" + ILessonDAO.StartDate + " is null OR " + ILessonDAO.StartDate + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andStartDateEqualTo(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.StartDate + " = ", value, "startDate");
            return this;
        }
        
        public Criteria andStartDateEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.StartDate);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartDateEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartDate + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andStartDateNotEqualTo(java.util.Date value) {
        	        
            addCriterionForJDBCDate(ILessonDAO.StartDate + " <>", value, "startDate");
            return this;
        }
               
        public Criteria andStartDateNotEqualToOrIsNull(java.util.Date value) {
        	        
            addCriterionForJDBCDate(ILessonDAO.StartDate + " is null OR " + ILessonDAO.StartDate + " <>", value, "startDate");
            return this;
        }
        
        public Criteria andStartDateNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.StartDate);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartDateNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartDate + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andStartDateGreaterThan(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.StartDate + " >", value, "startDate");
            return this;
        }
        
        public Criteria andStartDateGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.StartDate);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartDateGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartDate + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andStartDateGreaterThanOrEqualTo(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.StartDate + " >=", value, "startDate");
            return this;
        }
        
        public Criteria andStartDateGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.StartDate);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartDateGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartDate + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStartDateLessThan(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.StartDate + " <", value, "startDate");
            return this;
        }
        
        public Criteria andStartDateLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.StartDate);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartDateLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartDate + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStartDateLessThanOrEqualTo(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.StartDate + " <=", value, "startDate");
            return this;
        }
        
        public Criteria andStartDateLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.StartDate);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartDateLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartDate + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                public Criteria andStartDateIn(List<java.util.Date> values) {
        	
        	if(values.size() == 1){
        		return andStartDateEqualTo(values.get(0));
        	}
        	else{
            	addCriterionForJDBCDate(ILessonDAO.StartDate + " in", values, "startDate");
            	return this;
            }
        }
        public Criteria andStartDateNotIn(List<java.util.Date> values) {
        	if(values.size() == 1){
        		return andStartDateNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterionForJDBCDate(ILessonDAO.StartDate + " not in", values, "startDate");
            	return this;
            }
        }
        
        public Criteria andStartDateIn(java.util.Date[] values) {
        	
        	if(values.length == 1){
        		return andStartDateEqualTo(values[0]);
        	}
        	else{
            	addCriterionForJDBCDate(ILessonDAO.StartDate + " in", Arrays.asList(values), "startDate");
            	return this;
            }
        }
        public Criteria andStartDateNotIn(java.util.Date[] values) {
        	if(values.length == 1){
        		return andStartDateNotEqualTo(values[0]);
        	}
        	else{
            	addCriterionForJDBCDate(ILessonDAO.StartDate + " not in", Arrays.asList(values), "startDate");
            	return this;
            }
        }
		
		public Criteria andStartDateIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartDate + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andStartDateNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartDate + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStartDateBetween(java.util.Date value1, java.util.Date value2) {
            addCriterionForJDBCDate(ILessonDAO.StartDate + " between", value1, value2, "startDate");
            return this;
        }
        
                public Criteria andStartDateNotBetween(java.util.Date value1, java.util.Date value2) {
            addCriterionForJDBCDate(ILessonDAO.StartDate + " not between", value1, value2, "startDate");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andEndDateIsNull() {
            addCriterion(ILessonDAO.EndDate + " is null");
            return this;
        }
        public Criteria andEndDateIsNotNull() {
            addCriterion(ILessonDAO.EndDate + " is not null");
            return this;
        }
    
        public Criteria andEndDateIsNotEmpty() {        
            addCriterion(ILessonDAO.EndDate + " is not null AND " + ILessonDAO.EndDate + " <> ''");
            return this;
        }
    		
    	public Criteria andEndDateIsEmpty() {       
            addCriterion("(" + ILessonDAO.EndDate + " is null OR " + ILessonDAO.EndDate + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andEndDateEqualTo(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.EndDate + " = ", value, "endDate");
            return this;
        }
        
        public Criteria andEndDateEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.EndDate);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndDateEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndDate + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andEndDateNotEqualTo(java.util.Date value) {
        	        
            addCriterionForJDBCDate(ILessonDAO.EndDate + " <>", value, "endDate");
            return this;
        }
               
        public Criteria andEndDateNotEqualToOrIsNull(java.util.Date value) {
        	        
            addCriterionForJDBCDate(ILessonDAO.EndDate + " is null OR " + ILessonDAO.EndDate + " <>", value, "endDate");
            return this;
        }
        
        public Criteria andEndDateNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.EndDate);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndDateNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndDate + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andEndDateGreaterThan(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.EndDate + " >", value, "endDate");
            return this;
        }
        
        public Criteria andEndDateGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.EndDate);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndDateGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndDate + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andEndDateGreaterThanOrEqualTo(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.EndDate + " >=", value, "endDate");
            return this;
        }
        
        public Criteria andEndDateGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.EndDate);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndDateGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndDate + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andEndDateLessThan(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.EndDate + " <", value, "endDate");
            return this;
        }
        
        public Criteria andEndDateLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.EndDate);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndDateLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndDate + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andEndDateLessThanOrEqualTo(java.util.Date value) {
        				
            addCriterionForJDBCDate(ILessonDAO.EndDate + " <=", value, "endDate");
            return this;
        }
        
        public Criteria andEndDateLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.EndDate);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndDateLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndDate + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                public Criteria andEndDateIn(List<java.util.Date> values) {
        	
        	if(values.size() == 1){
        		return andEndDateEqualTo(values.get(0));
        	}
        	else{
            	addCriterionForJDBCDate(ILessonDAO.EndDate + " in", values, "endDate");
            	return this;
            }
        }
        public Criteria andEndDateNotIn(List<java.util.Date> values) {
        	if(values.size() == 1){
        		return andEndDateNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterionForJDBCDate(ILessonDAO.EndDate + " not in", values, "endDate");
            	return this;
            }
        }
        
        public Criteria andEndDateIn(java.util.Date[] values) {
        	
        	if(values.length == 1){
        		return andEndDateEqualTo(values[0]);
        	}
        	else{
            	addCriterionForJDBCDate(ILessonDAO.EndDate + " in", Arrays.asList(values), "endDate");
            	return this;
            }
        }
        public Criteria andEndDateNotIn(java.util.Date[] values) {
        	if(values.length == 1){
        		return andEndDateNotEqualTo(values[0]);
        	}
        	else{
            	addCriterionForJDBCDate(ILessonDAO.EndDate + " not in", Arrays.asList(values), "endDate");
            	return this;
            }
        }
		
		public Criteria andEndDateIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndDate + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andEndDateNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndDate + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andEndDateBetween(java.util.Date value1, java.util.Date value2) {
            addCriterionForJDBCDate(ILessonDAO.EndDate + " between", value1, value2, "endDate");
            return this;
        }
        
                public Criteria andEndDateNotBetween(java.util.Date value1, java.util.Date value2) {
            addCriterionForJDBCDate(ILessonDAO.EndDate + " not between", value1, value2, "endDate");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andMaxLessonCountIsNull() {
            addCriterion(ILessonDAO.MaxLessonCount + " is null");
            return this;
        }
        public Criteria andMaxLessonCountIsNotNull() {
            addCriterion(ILessonDAO.MaxLessonCount + " is not null");
            return this;
        }
    
        public Criteria andMaxLessonCountIsNotEmpty() {        
            addCriterion(ILessonDAO.MaxLessonCount + " is not null AND " + ILessonDAO.MaxLessonCount + " <> ''");
            return this;
        }
    		
    	public Criteria andMaxLessonCountIsEmpty() {       
            addCriterion("(" + ILessonDAO.MaxLessonCount + " is null OR " + ILessonDAO.MaxLessonCount + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andMaxLessonCountEqualTo(long value) {
        	return andMaxLessonCountEqualTo(Long.valueOf(value));
        }
               public Criteria andMaxLessonCountEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.MaxLessonCount + " = ", value, "maxLessonCount");
            return this;
        }
        
        public Criteria andMaxLessonCountEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.MaxLessonCount);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andMaxLessonCountEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.MaxLessonCount + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andMaxLessonCountNotEqualTo(long value) {
        	return andMaxLessonCountNotEqualTo(Long.valueOf(value));
        }
                public Criteria andMaxLessonCountNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.MaxLessonCount + " <>", value, "maxLessonCount");
            return this;
        }
               
        public Criteria andMaxLessonCountNotEqualToOrIsNull(long value) {
        	return andMaxLessonCountNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andMaxLessonCountNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.MaxLessonCount + " is null OR " + ILessonDAO.MaxLessonCount + " <>", value, "maxLessonCount");
            return this;
        }
        
        public Criteria andMaxLessonCountNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.MaxLessonCount);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andMaxLessonCountNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.MaxLessonCount + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andMaxLessonCountGreaterThan(long value) {
        	return andMaxLessonCountGreaterThan(Long.valueOf(value));
        }
                public Criteria andMaxLessonCountGreaterThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.MaxLessonCount + " >", value, "maxLessonCount");
            return this;
        }
        
        public Criteria andMaxLessonCountGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.MaxLessonCount);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andMaxLessonCountGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.MaxLessonCount + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andMaxLessonCountGreaterThanOrEqualTo(long value) {
        	return andMaxLessonCountGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andMaxLessonCountGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.MaxLessonCount + " >=", value, "maxLessonCount");
            return this;
        }
        
        public Criteria andMaxLessonCountGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.MaxLessonCount);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andMaxLessonCountGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.MaxLessonCount + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andMaxLessonCountLessThan(long value) {
        	return andMaxLessonCountLessThan(Long.valueOf(value));
        }
                public Criteria andMaxLessonCountLessThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.MaxLessonCount + " <", value, "maxLessonCount");
            return this;
        }
        
        public Criteria andMaxLessonCountLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.MaxLessonCount);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andMaxLessonCountLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.MaxLessonCount + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andMaxLessonCountLessThanOrEqualTo(long value) {
        	return andMaxLessonCountLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andMaxLessonCountLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.MaxLessonCount + " <=", value, "maxLessonCount");
            return this;
        }
        
        public Criteria andMaxLessonCountLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.MaxLessonCount);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andMaxLessonCountLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.MaxLessonCount + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andMaxLessonCountIn(long[] values) {
        	if(values.length == 1){
        		return andMaxLessonCountEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.MaxLessonCount + " in", values, "maxLessonCount");
            	return this;
            }
        }
        
        public Criteria andMaxLessonCountNotIn(long[] values) {
        	if(values.length == 1){
        		return andMaxLessonCountNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.MaxLessonCount + " not in", values, "maxLessonCount");
            	return this;
            }
        }
        
                public Criteria andMaxLessonCountIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andMaxLessonCountEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.MaxLessonCount + " in", values, "maxLessonCount");
            	return this;
            }
        }
        public Criteria andMaxLessonCountNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andMaxLessonCountNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.MaxLessonCount + " not in", values, "maxLessonCount");
            	return this;
            }
        }
        
        public Criteria andMaxLessonCountIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andMaxLessonCountEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.MaxLessonCount + " in", Arrays.asList(values), "maxLessonCount");
            	return this;
            }
        }
        public Criteria andMaxLessonCountNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andMaxLessonCountNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.MaxLessonCount + " not in", Arrays.asList(values), "maxLessonCount");
            	return this;
            }
        }
		
		public Criteria andMaxLessonCountIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.MaxLessonCount + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andMaxLessonCountNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.MaxLessonCount + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andMaxLessonCountBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.MaxLessonCount + " between", value1, value2, "maxLessonCount");
            return this;
        }
                public Criteria andMaxLessonCountBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.MaxLessonCount + " between", value1, value2, "maxLessonCount");
            return this;
        }
        
                
        public Criteria andMaxLessonCountNotBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.MaxLessonCount + " not between", value1, value2, "maxLessonCount");
            return this;
        }
                public Criteria andMaxLessonCountNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.MaxLessonCount + " not between", value1, value2, "maxLessonCount");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andStartLessonTimeIsNull() {
            addCriterion(ILessonDAO.StartLessonTime + " is null");
            return this;
        }
        public Criteria andStartLessonTimeIsNotNull() {
            addCriterion(ILessonDAO.StartLessonTime + " is not null");
            return this;
        }
    
        public Criteria andStartLessonTimeIsNotEmpty() {        
            addCriterion(ILessonDAO.StartLessonTime + " is not null AND " + ILessonDAO.StartLessonTime + " <> ''");
            return this;
        }
    		
    	public Criteria andStartLessonTimeIsEmpty() {       
            addCriterion("(" + ILessonDAO.StartLessonTime + " is null OR " + ILessonDAO.StartLessonTime + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andStartLessonTimeEqualTo(String value) {
        				
            addCriterion(ILessonDAO.StartLessonTime + " = ", value, "startLessonTime");
            return this;
        }
        
        public Criteria andStartLessonTimeEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.StartLessonTime);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartLessonTimeEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartLessonTime + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andStartLessonTimeNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.StartLessonTime + " <>", value, "startLessonTime");
            return this;
        }
               
        public Criteria andStartLessonTimeNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.StartLessonTime + " is null OR " + ILessonDAO.StartLessonTime + " <>", value, "startLessonTime");
            return this;
        }
        
        public Criteria andStartLessonTimeNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.StartLessonTime);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartLessonTimeNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartLessonTime + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andStartLessonTimeGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.StartLessonTime + " >", value, "startLessonTime");
            return this;
        }
        
        public Criteria andStartLessonTimeGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.StartLessonTime);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartLessonTimeGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartLessonTime + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andStartLessonTimeGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.StartLessonTime + " >=", value, "startLessonTime");
            return this;
        }
        
        public Criteria andStartLessonTimeGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.StartLessonTime);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartLessonTimeGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartLessonTime + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStartLessonTimeLessThan(String value) {
        				
            addCriterion(ILessonDAO.StartLessonTime + " <", value, "startLessonTime");
            return this;
        }
        
        public Criteria andStartLessonTimeLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.StartLessonTime);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartLessonTimeLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartLessonTime + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStartLessonTimeLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.StartLessonTime + " <=", value, "startLessonTime");
            return this;
        }
        
        public Criteria andStartLessonTimeLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.StartLessonTime);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStartLessonTimeLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartLessonTime + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andStartLessonTimeLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.StartLessonTime + " like", buffer.toString(), "startLessonTime");
            return this;
        }
        public Criteria andStartLessonTimeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.StartLessonTime + " not like", buffer.toString(), "startLessonTime");
            return this;
        }
                
                public Criteria andStartLessonTimeIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andStartLessonTimeEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.StartLessonTime + " in", values, "startLessonTime");
            	return this;
            }
        }
        public Criteria andStartLessonTimeNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andStartLessonTimeNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.StartLessonTime + " not in", values, "startLessonTime");
            	return this;
            }
        }
        
        public Criteria andStartLessonTimeIn(String[] values) {
        	
        	if(values.length == 1){
        		return andStartLessonTimeEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.StartLessonTime + " in", Arrays.asList(values), "startLessonTime");
            	return this;
            }
        }
        public Criteria andStartLessonTimeNotIn(String[] values) {
        	if(values.length == 1){
        		return andStartLessonTimeNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.StartLessonTime + " not in", Arrays.asList(values), "startLessonTime");
            	return this;
            }
        }
		
		public Criteria andStartLessonTimeIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartLessonTime + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andStartLessonTimeNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.StartLessonTime + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStartLessonTimeBetween(String value1, String value2) {
            addCriterion(ILessonDAO.StartLessonTime + " between", value1, value2, "startLessonTime");
            return this;
        }
        
                public Criteria andStartLessonTimeNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.StartLessonTime + " not between", value1, value2, "startLessonTime");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andEndLessonTimeIsNull() {
            addCriterion(ILessonDAO.EndLessonTime + " is null");
            return this;
        }
        public Criteria andEndLessonTimeIsNotNull() {
            addCriterion(ILessonDAO.EndLessonTime + " is not null");
            return this;
        }
    
        public Criteria andEndLessonTimeIsNotEmpty() {        
            addCriterion(ILessonDAO.EndLessonTime + " is not null AND " + ILessonDAO.EndLessonTime + " <> ''");
            return this;
        }
    		
    	public Criteria andEndLessonTimeIsEmpty() {       
            addCriterion("(" + ILessonDAO.EndLessonTime + " is null OR " + ILessonDAO.EndLessonTime + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andEndLessonTimeEqualTo(String value) {
        				
            addCriterion(ILessonDAO.EndLessonTime + " = ", value, "endLessonTime");
            return this;
        }
        
        public Criteria andEndLessonTimeEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.EndLessonTime);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndLessonTimeEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndLessonTime + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andEndLessonTimeNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.EndLessonTime + " <>", value, "endLessonTime");
            return this;
        }
               
        public Criteria andEndLessonTimeNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.EndLessonTime + " is null OR " + ILessonDAO.EndLessonTime + " <>", value, "endLessonTime");
            return this;
        }
        
        public Criteria andEndLessonTimeNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.EndLessonTime);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndLessonTimeNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndLessonTime + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andEndLessonTimeGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.EndLessonTime + " >", value, "endLessonTime");
            return this;
        }
        
        public Criteria andEndLessonTimeGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.EndLessonTime);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndLessonTimeGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndLessonTime + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andEndLessonTimeGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.EndLessonTime + " >=", value, "endLessonTime");
            return this;
        }
        
        public Criteria andEndLessonTimeGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.EndLessonTime);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndLessonTimeGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndLessonTime + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andEndLessonTimeLessThan(String value) {
        				
            addCriterion(ILessonDAO.EndLessonTime + " <", value, "endLessonTime");
            return this;
        }
        
        public Criteria andEndLessonTimeLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.EndLessonTime);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndLessonTimeLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndLessonTime + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andEndLessonTimeLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.EndLessonTime + " <=", value, "endLessonTime");
            return this;
        }
        
        public Criteria andEndLessonTimeLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.EndLessonTime);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andEndLessonTimeLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndLessonTime + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andEndLessonTimeLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.EndLessonTime + " like", buffer.toString(), "endLessonTime");
            return this;
        }
        public Criteria andEndLessonTimeNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.EndLessonTime + " not like", buffer.toString(), "endLessonTime");
            return this;
        }
                
                public Criteria andEndLessonTimeIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andEndLessonTimeEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.EndLessonTime + " in", values, "endLessonTime");
            	return this;
            }
        }
        public Criteria andEndLessonTimeNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andEndLessonTimeNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.EndLessonTime + " not in", values, "endLessonTime");
            	return this;
            }
        }
        
        public Criteria andEndLessonTimeIn(String[] values) {
        	
        	if(values.length == 1){
        		return andEndLessonTimeEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.EndLessonTime + " in", Arrays.asList(values), "endLessonTime");
            	return this;
            }
        }
        public Criteria andEndLessonTimeNotIn(String[] values) {
        	if(values.length == 1){
        		return andEndLessonTimeNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.EndLessonTime + " not in", Arrays.asList(values), "endLessonTime");
            	return this;
            }
        }
		
		public Criteria andEndLessonTimeIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndLessonTime + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andEndLessonTimeNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.EndLessonTime + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andEndLessonTimeBetween(String value1, String value2) {
            addCriterion(ILessonDAO.EndLessonTime + " between", value1, value2, "endLessonTime");
            return this;
        }
        
                public Criteria andEndLessonTimeNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.EndLessonTime + " not between", value1, value2, "endLessonTime");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andLessonTopicIsNull() {
            addCriterion(ILessonDAO.LessonTopic + " is null");
            return this;
        }
        public Criteria andLessonTopicIsNotNull() {
            addCriterion(ILessonDAO.LessonTopic + " is not null");
            return this;
        }
    
        public Criteria andLessonTopicIsNotEmpty() {        
            addCriterion(ILessonDAO.LessonTopic + " is not null AND " + ILessonDAO.LessonTopic + " <> ''");
            return this;
        }
    		
    	public Criteria andLessonTopicIsEmpty() {       
            addCriterion("(" + ILessonDAO.LessonTopic + " is null OR " + ILessonDAO.LessonTopic + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andLessonTopicEqualTo(String value) {
        				
            addCriterion(ILessonDAO.LessonTopic + " = ", value, "lessonTopic");
            return this;
        }
        
        public Criteria andLessonTopicEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.LessonTopic);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andLessonTopicEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.LessonTopic + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andLessonTopicNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.LessonTopic + " <>", value, "lessonTopic");
            return this;
        }
               
        public Criteria andLessonTopicNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.LessonTopic + " is null OR " + ILessonDAO.LessonTopic + " <>", value, "lessonTopic");
            return this;
        }
        
        public Criteria andLessonTopicNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.LessonTopic);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andLessonTopicNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.LessonTopic + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andLessonTopicGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.LessonTopic + " >", value, "lessonTopic");
            return this;
        }
        
        public Criteria andLessonTopicGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.LessonTopic);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andLessonTopicGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.LessonTopic + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andLessonTopicGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.LessonTopic + " >=", value, "lessonTopic");
            return this;
        }
        
        public Criteria andLessonTopicGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.LessonTopic);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andLessonTopicGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.LessonTopic + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andLessonTopicLessThan(String value) {
        				
            addCriterion(ILessonDAO.LessonTopic + " <", value, "lessonTopic");
            return this;
        }
        
        public Criteria andLessonTopicLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.LessonTopic);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andLessonTopicLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.LessonTopic + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andLessonTopicLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.LessonTopic + " <=", value, "lessonTopic");
            return this;
        }
        
        public Criteria andLessonTopicLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.LessonTopic);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andLessonTopicLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.LessonTopic + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andLessonTopicLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.LessonTopic + " like", buffer.toString(), "lessonTopic");
            return this;
        }
        public Criteria andLessonTopicNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.LessonTopic + " not like", buffer.toString(), "lessonTopic");
            return this;
        }
                
                public Criteria andLessonTopicIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andLessonTopicEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.LessonTopic + " in", values, "lessonTopic");
            	return this;
            }
        }
        public Criteria andLessonTopicNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andLessonTopicNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.LessonTopic + " not in", values, "lessonTopic");
            	return this;
            }
        }
        
        public Criteria andLessonTopicIn(String[] values) {
        	
        	if(values.length == 1){
        		return andLessonTopicEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.LessonTopic + " in", Arrays.asList(values), "lessonTopic");
            	return this;
            }
        }
        public Criteria andLessonTopicNotIn(String[] values) {
        	if(values.length == 1){
        		return andLessonTopicNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.LessonTopic + " not in", Arrays.asList(values), "lessonTopic");
            	return this;
            }
        }
		
		public Criteria andLessonTopicIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.LessonTopic + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andLessonTopicNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.LessonTopic + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andLessonTopicBetween(String value1, String value2) {
            addCriterion(ILessonDAO.LessonTopic + " between", value1, value2, "lessonTopic");
            return this;
        }
        
                public Criteria andLessonTopicNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.LessonTopic + " not between", value1, value2, "lessonTopic");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andDeleteFlagIsNull() {
            addCriterion(ILessonDAO.DeleteFlag + " is null");
            return this;
        }
        public Criteria andDeleteFlagIsNotNull() {
            addCriterion(ILessonDAO.DeleteFlag + " is not null");
            return this;
        }
    
        public Criteria andDeleteFlagIsNotEmpty() {        
            addCriterion(ILessonDAO.DeleteFlag + " is not null AND " + ILessonDAO.DeleteFlag + " <> ''");
            return this;
        }
    		
    	public Criteria andDeleteFlagIsEmpty() {       
            addCriterion("(" + ILessonDAO.DeleteFlag + " is null OR " + ILessonDAO.DeleteFlag + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andDeleteFlagEqualTo(long value) {
        	return andDeleteFlagEqualTo(Long.valueOf(value));
        }
               public Criteria andDeleteFlagEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.DeleteFlag + " = ", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.DeleteFlag);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.DeleteFlag + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andDeleteFlagNotEqualTo(long value) {
        	return andDeleteFlagNotEqualTo(Long.valueOf(value));
        }
                public Criteria andDeleteFlagNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.DeleteFlag + " <>", value, "deleteFlag");
            return this;
        }
               
        public Criteria andDeleteFlagNotEqualToOrIsNull(long value) {
        	return andDeleteFlagNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andDeleteFlagNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.DeleteFlag + " is null OR " + ILessonDAO.DeleteFlag + " <>", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.DeleteFlag);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.DeleteFlag + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andDeleteFlagGreaterThan(long value) {
        	return andDeleteFlagGreaterThan(Long.valueOf(value));
        }
                public Criteria andDeleteFlagGreaterThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.DeleteFlag + " >", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.DeleteFlag);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.DeleteFlag + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andDeleteFlagGreaterThanOrEqualTo(long value) {
        	return andDeleteFlagGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andDeleteFlagGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.DeleteFlag + " >=", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.DeleteFlag);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.DeleteFlag + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andDeleteFlagLessThan(long value) {
        	return andDeleteFlagLessThan(Long.valueOf(value));
        }
                public Criteria andDeleteFlagLessThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.DeleteFlag + " <", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.DeleteFlag);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.DeleteFlag + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andDeleteFlagLessThanOrEqualTo(long value) {
        	return andDeleteFlagLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andDeleteFlagLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.DeleteFlag + " <=", value, "deleteFlag");
            return this;
        }
        
        public Criteria andDeleteFlagLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.DeleteFlag);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andDeleteFlagLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.DeleteFlag + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andDeleteFlagIn(long[] values) {
        	if(values.length == 1){
        		return andDeleteFlagEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.DeleteFlag + " in", values, "deleteFlag");
            	return this;
            }
        }
        
        public Criteria andDeleteFlagNotIn(long[] values) {
        	if(values.length == 1){
        		return andDeleteFlagNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.DeleteFlag + " not in", values, "deleteFlag");
            	return this;
            }
        }
        
                public Criteria andDeleteFlagIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andDeleteFlagEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.DeleteFlag + " in", values, "deleteFlag");
            	return this;
            }
        }
        public Criteria andDeleteFlagNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andDeleteFlagNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.DeleteFlag + " not in", values, "deleteFlag");
            	return this;
            }
        }
        
        public Criteria andDeleteFlagIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andDeleteFlagEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.DeleteFlag + " in", Arrays.asList(values), "deleteFlag");
            	return this;
            }
        }
        public Criteria andDeleteFlagNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andDeleteFlagNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.DeleteFlag + " not in", Arrays.asList(values), "deleteFlag");
            	return this;
            }
        }
		
		public Criteria andDeleteFlagIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.DeleteFlag + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andDeleteFlagNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.DeleteFlag + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andDeleteFlagBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.DeleteFlag + " between", value1, value2, "deleteFlag");
            return this;
        }
                public Criteria andDeleteFlagBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.DeleteFlag + " between", value1, value2, "deleteFlag");
            return this;
        }
        
                
        public Criteria andDeleteFlagNotBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.DeleteFlag + " not between", value1, value2, "deleteFlag");
            return this;
        }
                public Criteria andDeleteFlagNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.DeleteFlag + " not between", value1, value2, "deleteFlag");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andStatusIsNull() {
            addCriterion(ILessonDAO.Status + " is null");
            return this;
        }
        public Criteria andStatusIsNotNull() {
            addCriterion(ILessonDAO.Status + " is not null");
            return this;
        }
    
        public Criteria andStatusIsNotEmpty() {        
            addCriterion(ILessonDAO.Status + " is not null AND " + ILessonDAO.Status + " <> ''");
            return this;
        }
    		
    	public Criteria andStatusIsEmpty() {       
            addCriterion("(" + ILessonDAO.Status + " is null OR " + ILessonDAO.Status + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andStatusEqualTo(String value) {
        				
            addCriterion(ILessonDAO.Status + " = ", value, "status");
            return this;
        }
        
        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.Status);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Status + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andStatusNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.Status + " <>", value, "status");
            return this;
        }
               
        public Criteria andStatusNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.Status + " is null OR " + ILessonDAO.Status + " <>", value, "status");
            return this;
        }
        
        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.Status);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Status + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andStatusGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.Status + " >", value, "status");
            return this;
        }
        
        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.Status);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Status + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andStatusGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.Status + " >=", value, "status");
            return this;
        }
        
        public Criteria andStatusGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.Status);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Status + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStatusLessThan(String value) {
        				
            addCriterion(ILessonDAO.Status + " <", value, "status");
            return this;
        }
        
        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.Status);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Status + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStatusLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.Status + " <=", value, "status");
            return this;
        }
        
        public Criteria andStatusLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.Status);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Status + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andStatusLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.Status + " like", buffer.toString(), "status");
            return this;
        }
        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.Status + " not like", buffer.toString(), "status");
            return this;
        }
                
                public Criteria andStatusIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andStatusEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.Status + " in", values, "status");
            	return this;
            }
        }
        public Criteria andStatusNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andStatusNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.Status + " not in", values, "status");
            	return this;
            }
        }
        
        public Criteria andStatusIn(String[] values) {
        	
        	if(values.length == 1){
        		return andStatusEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.Status + " in", Arrays.asList(values), "status");
            	return this;
            }
        }
        public Criteria andStatusNotIn(String[] values) {
        	if(values.length == 1){
        		return andStatusNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.Status + " not in", Arrays.asList(values), "status");
            	return this;
            }
        }
		
		public Criteria andStatusIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Status + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Status + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(ILessonDAO.Status + " between", value1, value2, "status");
            return this;
        }
        
                public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.Status + " not between", value1, value2, "status");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andRemarksIsNull() {
            addCriterion(ILessonDAO.Remarks + " is null");
            return this;
        }
        public Criteria andRemarksIsNotNull() {
            addCriterion(ILessonDAO.Remarks + " is not null");
            return this;
        }
    
        public Criteria andRemarksIsNotEmpty() {        
            addCriterion(ILessonDAO.Remarks + " is not null AND " + ILessonDAO.Remarks + " <> ''");
            return this;
        }
    		
    	public Criteria andRemarksIsEmpty() {       
            addCriterion("(" + ILessonDAO.Remarks + " is null OR " + ILessonDAO.Remarks + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andRemarksEqualTo(String value) {
        				
            addCriterion(ILessonDAO.Remarks + " = ", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.Remarks);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Remarks + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andRemarksNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.Remarks + " <>", value, "remarks");
            return this;
        }
               
        public Criteria andRemarksNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.Remarks + " is null OR " + ILessonDAO.Remarks + " <>", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.Remarks);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Remarks + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andRemarksGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.Remarks + " >", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.Remarks);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Remarks + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andRemarksGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.Remarks + " >=", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.Remarks);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Remarks + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRemarksLessThan(String value) {
        				
            addCriterion(ILessonDAO.Remarks + " <", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.Remarks);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Remarks + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRemarksLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.Remarks + " <=", value, "remarks");
            return this;
        }
        
        public Criteria andRemarksLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.Remarks);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andRemarksLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Remarks + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andRemarksLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.Remarks + " like", buffer.toString(), "remarks");
            return this;
        }
        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.Remarks + " not like", buffer.toString(), "remarks");
            return this;
        }
                
                public Criteria andRemarksIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andRemarksEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.Remarks + " in", values, "remarks");
            	return this;
            }
        }
        public Criteria andRemarksNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andRemarksNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.Remarks + " not in", values, "remarks");
            	return this;
            }
        }
        
        public Criteria andRemarksIn(String[] values) {
        	
        	if(values.length == 1){
        		return andRemarksEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.Remarks + " in", Arrays.asList(values), "remarks");
            	return this;
            }
        }
        public Criteria andRemarksNotIn(String[] values) {
        	if(values.length == 1){
        		return andRemarksNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.Remarks + " not in", Arrays.asList(values), "remarks");
            	return this;
            }
        }
		
		public Criteria andRemarksIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Remarks + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.Remarks + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(ILessonDAO.Remarks + " between", value1, value2, "remarks");
            return this;
        }
        
                public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.Remarks + " not between", value1, value2, "remarks");
            return this;
        }
        
            	
    	    	
    	    	
    	        
                
        public Criteria andCourseIdIsNull() {
            addCriterion(ILessonDAO.CourseId + " is null");
            return this;
        }
        public Criteria andCourseIdIsNotNull() {
            addCriterion(ILessonDAO.CourseId + " is not null");
            return this;
        }
    
        public Criteria andCourseIdIsNotEmpty() {        
            addCriterion(ILessonDAO.CourseId + " is not null AND " + ILessonDAO.CourseId + " <> ''");
            return this;
        }
    		
    	public Criteria andCourseIdIsEmpty() {       
            addCriterion("(" + ILessonDAO.CourseId + " is null OR " + ILessonDAO.CourseId + " = '')");
            return this;
        }
        
                
                        
                        
                                
        public Criteria andCourseIdEqualTo(long value) {
        	return andCourseIdEqualTo(Long.valueOf(value));
        }
               public Criteria andCourseIdEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CourseId + " = ", value, "courseId");
            return this;
        }
        
        public Criteria andCourseIdEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CourseId);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseIdEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseId + " = ", subQueryBean, dao);
			return this;
		}
                
        public Criteria andCourseIdNotEqualTo(long value) {
        	return andCourseIdNotEqualTo(Long.valueOf(value));
        }
                public Criteria andCourseIdNotEqualTo(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.CourseId + " <>", value, "courseId");
            return this;
        }
               
        public Criteria andCourseIdNotEqualToOrIsNull(long value) {
        	return andCourseIdNotEqualToOrIsNull(Long.valueOf(value));
        }
                
        public Criteria andCourseIdNotEqualToOrIsNull(java.lang.Long value) {
        	        
            addCriterion(ILessonDAO.CourseId + " is null OR " + ILessonDAO.CourseId + " <>", value, "courseId");
            return this;
        }
        
        public Criteria andCourseIdNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CourseId);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseIdNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseId + " <> ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andCourseIdGreaterThan(long value) {
        	return andCourseIdGreaterThan(Long.valueOf(value));
        }
                public Criteria andCourseIdGreaterThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CourseId + " >", value, "courseId");
            return this;
        }
        
        public Criteria andCourseIdGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CourseId);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseIdGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseId + " > ", subQueryBean, dao);
			return this;
		}
               
        public Criteria andCourseIdGreaterThanOrEqualTo(long value) {
        	return andCourseIdGreaterThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andCourseIdGreaterThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CourseId + " >=", value, "courseId");
            return this;
        }
        
        public Criteria andCourseIdGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CourseId);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseId + " >= ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCourseIdLessThan(long value) {
        	return andCourseIdLessThan(Long.valueOf(value));
        }
                public Criteria andCourseIdLessThan(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CourseId + " <", value, "courseId");
            return this;
        }
        
        public Criteria andCourseIdLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CourseId);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseIdLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseId + " < ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCourseIdLessThanOrEqualTo(long value) {
        	return andCourseIdLessThanOrEqualTo(Long.valueOf(value));
        }
                public Criteria andCourseIdLessThanOrEqualTo(java.lang.Long value) {
        				
            addCriterion(ILessonDAO.CourseId + " <=", value, "courseId");
            return this;
        }
        
        public Criteria andCourseIdLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CourseId);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseId + " <= ", subQueryBean, dao);
			return this;
		}
		
		        
                
        public Criteria andCourseIdIn(long[] values) {
        	if(values.length == 1){
        		return andCourseIdEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CourseId + " in", values, "courseId");
            	return this;
            }
        }
        
        public Criteria andCourseIdNotIn(long[] values) {
        	if(values.length == 1){
        		return andCourseIdNotEqualTo((java.lang.Long)values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CourseId + " not in", values, "courseId");
            	return this;
            }
        }
        
                public Criteria andCourseIdIn(List<java.lang.Long> values) {
        	
        	if(values.size() == 1){
        		return andCourseIdEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CourseId + " in", values, "courseId");
            	return this;
            }
        }
        public Criteria andCourseIdNotIn(List<java.lang.Long> values) {
        	if(values.size() == 1){
        		return andCourseIdNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CourseId + " not in", values, "courseId");
            	return this;
            }
        }
        
        public Criteria andCourseIdIn(java.lang.Long[] values) {
        	
        	if(values.length == 1){
        		return andCourseIdEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CourseId + " in", Arrays.asList(values), "courseId");
            	return this;
            }
        }
        public Criteria andCourseIdNotIn(java.lang.Long[] values) {
        	if(values.length == 1){
        		return andCourseIdNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CourseId + " not in", Arrays.asList(values), "courseId");
            	return this;
            }
        }
		
		public Criteria andCourseIdIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseId + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andCourseIdNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseId + " not in ", subQueryBean, dao);
			return this;
		}
        
                
        public Criteria andCourseIdBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.CourseId + " between", value1, value2, "courseId");
            return this;
        }
                public Criteria andCourseIdBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.CourseId + " between", value1, value2, "courseId");
            return this;
        }
        
                
        public Criteria andCourseIdNotBetween(long value1,long value2) {
        	addCriterion(ILessonDAO.CourseId + " not between", value1, value2, "courseId");
            return this;
        }
                public Criteria andCourseIdNotBetween(java.lang.Long value1, java.lang.Long value2) {
            addCriterion(ILessonDAO.CourseId + " not between", value1, value2, "courseId");
            return this;
        }
        
            	
    	    	
    	    	    	    	    	    	
                
                
        public Criteria andCampusNameIsNull() {
            addCriterion(ILessonDAO.CampusName + " is null");
            return this;
        }
        public Criteria andCampusNameIsNotNull() {
            addCriterion(ILessonDAO.CampusName + " is not null");
            return this;
        }
    
        public Criteria andCampusNameIsNotEmpty() {        
            addCriterion(ILessonDAO.CampusName + " is not null AND " + ILessonDAO.CampusName + " <> ''");
            return this;
        }
    		
    	public Criteria andCampusNameIsEmpty() {       
            addCriterion("(" + ILessonDAO.CampusName + " is null OR " + ILessonDAO.CampusName + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andCampusNameEqualTo(String value) {
        				
            addCriterion(ILessonDAO.CampusName + " = ", value, "campusName");
            return this;
        }
        
        public Criteria andCampusNameEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CampusName);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusNameEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusName + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andCampusNameNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.CampusName + " <>", value, "campusName");
            return this;
        }
               
        public Criteria andCampusNameNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.CampusName + " is null OR " + ILessonDAO.CampusName + " <>", value, "campusName");
            return this;
        }
        
        public Criteria andCampusNameNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CampusName);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusNameNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusName + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andCampusNameGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.CampusName + " >", value, "campusName");
            return this;
        }
        
        public Criteria andCampusNameGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CampusName);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusNameGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusName + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andCampusNameGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.CampusName + " >=", value, "campusName");
            return this;
        }
        
        public Criteria andCampusNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CampusName);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusNameGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusName + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCampusNameLessThan(String value) {
        				
            addCriterion(ILessonDAO.CampusName + " <", value, "campusName");
            return this;
        }
        
        public Criteria andCampusNameLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CampusName);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusNameLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusName + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCampusNameLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.CampusName + " <=", value, "campusName");
            return this;
        }
        
        public Criteria andCampusNameLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CampusName);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCampusNameLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusName + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andCampusNameLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.CampusName + " like", buffer.toString(), "campusName");
            return this;
        }
        public Criteria andCampusNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.CampusName + " not like", buffer.toString(), "campusName");
            return this;
        }
                
                public Criteria andCampusNameIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andCampusNameEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CampusName + " in", values, "campusName");
            	return this;
            }
        }
        public Criteria andCampusNameNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andCampusNameNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CampusName + " not in", values, "campusName");
            	return this;
            }
        }
        
        public Criteria andCampusNameIn(String[] values) {
        	
        	if(values.length == 1){
        		return andCampusNameEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CampusName + " in", Arrays.asList(values), "campusName");
            	return this;
            }
        }
        public Criteria andCampusNameNotIn(String[] values) {
        	if(values.length == 1){
        		return andCampusNameNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CampusName + " not in", Arrays.asList(values), "campusName");
            	return this;
            }
        }
		
		public Criteria andCampusNameIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusName + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andCampusNameNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CampusName + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCampusNameBetween(String value1, String value2) {
            addCriterion(ILessonDAO.CampusName + " between", value1, value2, "campusName");
            return this;
        }
        
                public Criteria andCampusNameNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.CampusName + " not between", value1, value2, "campusName");
            return this;
        }
        
            	
    	    	    	    	    	    	    	    	
                
                
        public Criteria andClassroomNameIsNull() {
            addCriterion(ILessonDAO.ClassroomName + " is null");
            return this;
        }
        public Criteria andClassroomNameIsNotNull() {
            addCriterion(ILessonDAO.ClassroomName + " is not null");
            return this;
        }
    
        public Criteria andClassroomNameIsNotEmpty() {        
            addCriterion(ILessonDAO.ClassroomName + " is not null AND " + ILessonDAO.ClassroomName + " <> ''");
            return this;
        }
    		
    	public Criteria andClassroomNameIsEmpty() {       
            addCriterion("(" + ILessonDAO.ClassroomName + " is null OR " + ILessonDAO.ClassroomName + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andClassroomNameEqualTo(String value) {
        				
            addCriterion(ILessonDAO.ClassroomName + " = ", value, "classroomName");
            return this;
        }
        
        public Criteria andClassroomNameEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassroomName);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomNameEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomName + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andClassroomNameNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.ClassroomName + " <>", value, "classroomName");
            return this;
        }
               
        public Criteria andClassroomNameNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.ClassroomName + " is null OR " + ILessonDAO.ClassroomName + " <>", value, "classroomName");
            return this;
        }
        
        public Criteria andClassroomNameNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassroomName);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomNameNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomName + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andClassroomNameGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.ClassroomName + " >", value, "classroomName");
            return this;
        }
        
        public Criteria andClassroomNameGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassroomName);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomNameGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomName + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andClassroomNameGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.ClassroomName + " >=", value, "classroomName");
            return this;
        }
        
        public Criteria andClassroomNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassroomName);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomNameGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomName + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andClassroomNameLessThan(String value) {
        				
            addCriterion(ILessonDAO.ClassroomName + " <", value, "classroomName");
            return this;
        }
        
        public Criteria andClassroomNameLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassroomName);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomNameLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomName + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andClassroomNameLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.ClassroomName + " <=", value, "classroomName");
            return this;
        }
        
        public Criteria andClassroomNameLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassroomName);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassroomNameLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomName + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andClassroomNameLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.ClassroomName + " like", buffer.toString(), "classroomName");
            return this;
        }
        public Criteria andClassroomNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.ClassroomName + " not like", buffer.toString(), "classroomName");
            return this;
        }
                
                public Criteria andClassroomNameIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andClassroomNameEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomName + " in", values, "classroomName");
            	return this;
            }
        }
        public Criteria andClassroomNameNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andClassroomNameNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomName + " not in", values, "classroomName");
            	return this;
            }
        }
        
        public Criteria andClassroomNameIn(String[] values) {
        	
        	if(values.length == 1){
        		return andClassroomNameEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomName + " in", Arrays.asList(values), "classroomName");
            	return this;
            }
        }
        public Criteria andClassroomNameNotIn(String[] values) {
        	if(values.length == 1){
        		return andClassroomNameNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassroomName + " not in", Arrays.asList(values), "classroomName");
            	return this;
            }
        }
		
		public Criteria andClassroomNameIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomName + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andClassroomNameNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassroomName + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andClassroomNameBetween(String value1, String value2) {
            addCriterion(ILessonDAO.ClassroomName + " between", value1, value2, "classroomName");
            return this;
        }
        
                public Criteria andClassroomNameNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.ClassroomName + " not between", value1, value2, "classroomName");
            return this;
        }
        
            	
    	    	    	    	    	    	    	    	
                
                
        public Criteria andClassNameIsNull() {
            addCriterion(ILessonDAO.ClassName + " is null");
            return this;
        }
        public Criteria andClassNameIsNotNull() {
            addCriterion(ILessonDAO.ClassName + " is not null");
            return this;
        }
    
        public Criteria andClassNameIsNotEmpty() {        
            addCriterion(ILessonDAO.ClassName + " is not null AND " + ILessonDAO.ClassName + " <> ''");
            return this;
        }
    		
    	public Criteria andClassNameIsEmpty() {       
            addCriterion("(" + ILessonDAO.ClassName + " is null OR " + ILessonDAO.ClassName + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andClassNameEqualTo(String value) {
        				
            addCriterion(ILessonDAO.ClassName + " = ", value, "className");
            return this;
        }
        
        public Criteria andClassNameEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassName);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassNameEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassName + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andClassNameNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.ClassName + " <>", value, "className");
            return this;
        }
               
        public Criteria andClassNameNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.ClassName + " is null OR " + ILessonDAO.ClassName + " <>", value, "className");
            return this;
        }
        
        public Criteria andClassNameNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassName);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassNameNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassName + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andClassNameGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.ClassName + " >", value, "className");
            return this;
        }
        
        public Criteria andClassNameGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.ClassName);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassNameGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassName + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andClassNameGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.ClassName + " >=", value, "className");
            return this;
        }
        
        public Criteria andClassNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassName);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassNameGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassName + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andClassNameLessThan(String value) {
        				
            addCriterion(ILessonDAO.ClassName + " <", value, "className");
            return this;
        }
        
        public Criteria andClassNameLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassName);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassNameLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassName + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andClassNameLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.ClassName + " <=", value, "className");
            return this;
        }
        
        public Criteria andClassNameLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.ClassName);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andClassNameLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassName + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andClassNameLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.ClassName + " like", buffer.toString(), "className");
            return this;
        }
        public Criteria andClassNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.ClassName + " not like", buffer.toString(), "className");
            return this;
        }
                
                public Criteria andClassNameIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andClassNameEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ClassName + " in", values, "className");
            	return this;
            }
        }
        public Criteria andClassNameNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andClassNameNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.ClassName + " not in", values, "className");
            	return this;
            }
        }
        
        public Criteria andClassNameIn(String[] values) {
        	
        	if(values.length == 1){
        		return andClassNameEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassName + " in", Arrays.asList(values), "className");
            	return this;
            }
        }
        public Criteria andClassNameNotIn(String[] values) {
        	if(values.length == 1){
        		return andClassNameNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.ClassName + " not in", Arrays.asList(values), "className");
            	return this;
            }
        }
		
		public Criteria andClassNameIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassName + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andClassNameNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.ClassName + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andClassNameBetween(String value1, String value2) {
            addCriterion(ILessonDAO.ClassName + " between", value1, value2, "className");
            return this;
        }
        
                public Criteria andClassNameNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.ClassName + " not between", value1, value2, "className");
            return this;
        }
        
            	
    	    	    	    	    	    	    	    	
                
                
        public Criteria andTeacherNameIsNull() {
            addCriterion(ILessonDAO.TeacherName + " is null");
            return this;
        }
        public Criteria andTeacherNameIsNotNull() {
            addCriterion(ILessonDAO.TeacherName + " is not null");
            return this;
        }
    
        public Criteria andTeacherNameIsNotEmpty() {        
            addCriterion(ILessonDAO.TeacherName + " is not null AND " + ILessonDAO.TeacherName + " <> ''");
            return this;
        }
    		
    	public Criteria andTeacherNameIsEmpty() {       
            addCriterion("(" + ILessonDAO.TeacherName + " is null OR " + ILessonDAO.TeacherName + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andTeacherNameEqualTo(String value) {
        				
            addCriterion(ILessonDAO.TeacherName + " = ", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.TeacherName);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherName + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andTeacherNameNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.TeacherName + " <>", value, "teacherName");
            return this;
        }
               
        public Criteria andTeacherNameNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.TeacherName + " is null OR " + ILessonDAO.TeacherName + " <>", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.TeacherName);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherName + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeacherNameGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.TeacherName + " >", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.TeacherName);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherName + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andTeacherNameGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.TeacherName + " >=", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.TeacherName);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherName + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherNameLessThan(String value) {
        				
            addCriterion(ILessonDAO.TeacherName + " <", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.TeacherName);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherName + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherNameLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.TeacherName + " <=", value, "teacherName");
            return this;
        }
        
        public Criteria andTeacherNameLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.TeacherName);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andTeacherNameLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherName + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andTeacherNameLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.TeacherName + " like", buffer.toString(), "teacherName");
            return this;
        }
        public Criteria andTeacherNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.TeacherName + " not like", buffer.toString(), "teacherName");
            return this;
        }
                
                public Criteria andTeacherNameIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andTeacherNameEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherName + " in", values, "teacherName");
            	return this;
            }
        }
        public Criteria andTeacherNameNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andTeacherNameNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherName + " not in", values, "teacherName");
            	return this;
            }
        }
        
        public Criteria andTeacherNameIn(String[] values) {
        	
        	if(values.length == 1){
        		return andTeacherNameEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherName + " in", Arrays.asList(values), "teacherName");
            	return this;
            }
        }
        public Criteria andTeacherNameNotIn(String[] values) {
        	if(values.length == 1){
        		return andTeacherNameNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.TeacherName + " not in", Arrays.asList(values), "teacherName");
            	return this;
            }
        }
		
		public Criteria andTeacherNameIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherName + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andTeacherNameNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.TeacherName + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andTeacherNameBetween(String value1, String value2) {
            addCriterion(ILessonDAO.TeacherName + " between", value1, value2, "teacherName");
            return this;
        }
        
                public Criteria andTeacherNameNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.TeacherName + " not between", value1, value2, "teacherName");
            return this;
        }
        
            	
    	    	    	    	    	    	    	    	
                
                
        public Criteria andCourseNameIsNull() {
            addCriterion(ILessonDAO.CourseName + " is null");
            return this;
        }
        public Criteria andCourseNameIsNotNull() {
            addCriterion(ILessonDAO.CourseName + " is not null");
            return this;
        }
    
        public Criteria andCourseNameIsNotEmpty() {        
            addCriterion(ILessonDAO.CourseName + " is not null AND " + ILessonDAO.CourseName + " <> ''");
            return this;
        }
    		
    	public Criteria andCourseNameIsEmpty() {       
            addCriterion("(" + ILessonDAO.CourseName + " is null OR " + ILessonDAO.CourseName + " = '')");
            return this;
        }
        
                
                        
                        
                               public Criteria andCourseNameEqualTo(String value) {
        				
            addCriterion(ILessonDAO.CourseName + " = ", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CourseName);
	    str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseName + " = ", subQueryBean, dao);
			return this;
		}
                public Criteria andCourseNameNotEqualTo(String value) {
        	        
            addCriterion(ILessonDAO.CourseName + " <>", value, "courseName");
            return this;
        }
               
        public Criteria andCourseNameNotEqualToOrIsNull(String value) {
        	        
            addCriterion(ILessonDAO.CourseName + " is null OR " + ILessonDAO.CourseName + " <>", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameNotEqualToForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CourseName);
	    str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameNotEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseName + " <> ", subQueryBean, dao);
			return this;
		}
               public Criteria andCourseNameGreaterThan(String value) {
        				
            addCriterion(ILessonDAO.CourseName + " >", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameGreaterThanForeignKey(java.lang.String key) {
	    StringBuffer str = new StringBuffer(ILessonDAO.CourseName);
	    str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameGreaterThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseName + " > ", subQueryBean, dao);
			return this;
		}
               public Criteria andCourseNameGreaterThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.CourseName + " >=", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameGreaterThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CourseName);
			str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseName + " >= ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCourseNameLessThan(String value) {
        				
            addCriterion(ILessonDAO.CourseName + " <", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameLessThanForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CourseName);
			str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameLessThan(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseName + " < ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCourseNameLessThanOrEqualTo(String value) {
        				
            addCriterion(ILessonDAO.CourseName + " <=", value, "courseName");
            return this;
        }
        
        public Criteria andCourseNameLessThanOrEqualToForeignKey(java.lang.String key) {
			StringBuffer str = new StringBuffer(ILessonDAO.CourseName);
			str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());
            return this;
        }
		
		public Criteria andCourseNameLessThanOrEqualTo(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseName + " <= ", subQueryBean, dao);
			return this;
		}
		
				
        public Criteria andCourseNameLike(String value) {
        	StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.CourseName + " like", buffer.toString(), "courseName");
            return this;
        }
        public Criteria andCourseNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
        	buffer.append(value);
        	buffer.append("%");
            addCriterion(ILessonDAO.CourseName + " not like", buffer.toString(), "courseName");
            return this;
        }
                
                public Criteria andCourseNameIn(List<String> values) {
        	
        	if(values.size() == 1){
        		return andCourseNameEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CourseName + " in", values, "courseName");
            	return this;
            }
        }
        public Criteria andCourseNameNotIn(List<String> values) {
        	if(values.size() == 1){
        		return andCourseNameNotEqualTo(values.get(0));
        	}
        	else{
            	addCriterion(ILessonDAO.CourseName + " not in", values, "courseName");
            	return this;
            }
        }
        
        public Criteria andCourseNameIn(String[] values) {
        	
        	if(values.length == 1){
        		return andCourseNameEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CourseName + " in", Arrays.asList(values), "courseName");
            	return this;
            }
        }
        public Criteria andCourseNameNotIn(String[] values) {
        	if(values.length == 1){
        		return andCourseNameNotEqualTo(values[0]);
        	}
        	else{
            	addCriterion(ILessonDAO.CourseName + " not in", Arrays.asList(values), "courseName");
            	return this;
            }
        }
		
		public Criteria andCourseNameIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseName + " in ", subQueryBean, dao);
			return this;
		}
		
		public Criteria andCourseNameNotIn(BaseQueryBean subQueryBean,
				IDataAccessInterface<?, ?> dao) {
			addCriterion(ILessonDAO.CourseName + " not in ", subQueryBean, dao);
			return this;
		}
        
                public Criteria andCourseNameBetween(String value1, String value2) {
            addCriterion(ILessonDAO.CourseName + " between", value1, value2, "courseName");
            return this;
        }
        
                public Criteria andCourseNameNotBetween(String value1, String value2) {
            addCriterion(ILessonDAO.CourseName + " not between", value1, value2, "courseName");
            return this;
        }
        
            	
    	    	    	        
        
    }
	
    
}